﻿#if WINDOWS_UWP || NETFX_CORE
using System.Globalization;

namespace System.ComponentModel
{
	public class TypeConverter
	{
		public virtual bool CanConvertFrom(
			ITypeDescriptorContext context, Type sourceType)
		{
			return false;
		}

		public virtual object ConvertFrom(
			ITypeDescriptorContext context, CultureInfo culture, object value)
		{
			return null;
		}

		public object ConvertFrom(object context)
		{
			throw new NotImplementedException();
		}

		public bool CanConvertFrom(Type getType)
		{
			throw new NotImplementedException();
		}
	}

	public interface ITypeDescriptorContext
	{

	}

}

////
//// System.ComponentModel.TypeConverter.cs
////
//// Authors:
////   Gonzalo Paniagua Javier (gonzalo@ximian.com)
////   Andreas Nahr (ClassDevelopment@A-SoftTech.com)
////
//// (C) 2002/2003 Ximian, Inc (http://www.ximian.com)
//// (C) 2003 Andreas Nahr
////
//
////
//// Permission is hereby granted, free of charge, to any person obtaining
//// a copy of this software and associated documentation files (the
//// "Software"), to deal in the Software without restriction, including
//// without limitation the rights to use, copy, modify, merge, publish,
//// distribute, sublicense, and/or sell copies of the Software, and to
//// permit persons to whom the Software is furnished to do so, subject to
//// the following conditions:
//// 
//// The above copyright notice and this permission notice shall be
//// included in all copies or substantial portions of the Software.
//// 
//// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
//// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
//// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
//// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
//// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
//// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
//// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
////
//
//using System;
//using System.Collections;
//using System.Collections.Generic;
//using System.ComponentModel.Design.Serialization;
//using System.Globalization;
//using System.Linq;
//using System.Reflection;
//using System.Runtime.InteropServices;
//
//namespace System.ComponentModel
//{
//	public abstract class PropertyDescriptorDummy
//	{
//		public abstract object GetValue(object component);
//
//		public abstract void SetValue(object component, object value);
//
//		public abstract void ResetValue(object component);
//
//		public abstract bool CanResetValue(object component);
//
//		public abstract bool ShouldSerializeValue(object component);
//
//		public List<Attribute> Attributes = new List<Attribute>(); 
//	}
//
//	public class ComponentCollection
//	{
//	}
//
//	public interface IComponent : IDisposable
//	{
//		ISite Site { get; set; }
//		event EventHandler Disposed;
//	}
//
//	public interface ISite : IServiceProvider
//	{
//		IComponent Component { get; }
//
//		IContainer Container { get; }
//
//		bool DesignMode { get; }
//
//		string Name { get; set; }
//	}
//
//	public interface IContainer : IDisposable
//	{
//
//		ComponentCollection Components
//		{
//			get;
//		}
//
//		void Add(IComponent component);
//
//		void Add(IComponent component, string name);
//
//		void Remove(IComponent component);
//	}
//
//	public interface ITypeDescriptorContext : IServiceProvider
//	{
//		IContainer Container { get; }
//
//		object Instance { get; }
//
//		PropertyDescriptor PropertyDescriptor { get; }
//
//		void OnComponentChanged();
//
//		bool OnComponentChanging();
//	}
//
//	public abstract class PropertyDescriptor
//	{
//	}
//
//	public class TypeConverter
//	{
//		public bool CanConvertFrom(Type sourceType)
//		{
//			return CanConvertFrom(null, sourceType);
//		}
//
//		public virtual bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
//		{
//			if (sourceType == typeof(InstanceDescriptor))
//			{
//				return true;
//			}
//
//			return false;
//		}
//
//		public bool CanConvertTo(Type destinationType)
//		{
//			return CanConvertTo(null, destinationType);
//		}
//
//		public virtual bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
//		{
//			return (destinationType == typeof(string));
//		}
//
//		public object ConvertFrom(object o)
//		{
//			return ConvertFrom(null, CultureInfo.CurrentCulture, o);
//		}
//
//		public virtual object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
//		{
//			if (value is InstanceDescriptor)
//			{
//				return ((InstanceDescriptor)value).Invoke();
//			}
//
//			return GetConvertFromException(value);
//		}
//
//		public object ConvertFromInvariantString(string text)
//		{
//			return ConvertFromInvariantString(null, text);
//		}
//
//		public object ConvertFromInvariantString(ITypeDescriptorContext context, string text)
//		{
//			return ConvertFromString(context, CultureInfo.InvariantCulture, text);
//		}
//
//		public object ConvertFromString(string text)
//		{
//			return ConvertFrom(text);
//		}
//
//		public object ConvertFromString(ITypeDescriptorContext context, string text)
//		{
//			return ConvertFromString(context, CultureInfo.CurrentCulture, text);
//		}
//
//		public object ConvertFromString(ITypeDescriptorContext context, CultureInfo culture, string text)
//		{
//			return ConvertFrom(context, culture, text);
//		}
//
//		public object ConvertTo(object value, Type destinationType)
//		{
//			return ConvertTo(null, null, value, destinationType);
//		}
//
//		public virtual object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value,
//						 Type destinationType)
//		{
//			// context? culture?
//			if (destinationType == null)
//				throw new ArgumentNullException("destinationType");
//
//			if (destinationType == typeof(string))
//			{
//				if (value != null)
//					return value.ToString();
//				return String.Empty;
//			}
//
//			return GetConvertToException(value, destinationType);
//		}
//
//		public string ConvertToInvariantString(object value)
//		{
//			return ConvertToInvariantString(null, value);
//		}
//
//		public string ConvertToInvariantString(ITypeDescriptorContext context, object value)
//		{
//			return (string)ConvertTo(context, CultureInfo.InvariantCulture, value, typeof(string));
//		}
//
//		public string ConvertToString(object value)
//		{
//			return (string)ConvertTo(null, CultureInfo.CurrentCulture, value, typeof(string));
//		}
//
//		public string ConvertToString(ITypeDescriptorContext context, object value)
//		{
//			return (string)ConvertTo(context, CultureInfo.CurrentCulture, value, typeof(string));
//		}
//
//		public string ConvertToString(ITypeDescriptorContext context, CultureInfo culture, object value)
//		{
//			return (string)ConvertTo(context, culture, value, typeof(string));
//		}
//
//		protected Exception GetConvertFromException(object value)
//		{
//			string destinationType;
//			if (value == null)
//				destinationType = "(null)";
//			else
//				destinationType = value.GetType().FullName;
//
//			throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture,
//				"{0} cannot convert from {1}.", this.GetType().Name,
//				destinationType));
//		}
//
//		protected Exception GetConvertToException(object value, Type destinationType)
//		{
//			string sourceType;
//			if (value == null)
//				sourceType = "(null)";
//			else
//				sourceType = value.GetType().FullName;
//
//			throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture,
//				"'{0}' is unable to convert '{1}' to '{2}'.", this.GetType().Name,
//				sourceType, destinationType.FullName));
//		}
//
//		public object CreateInstance(IDictionary propertyValues)
//		{
//			return CreateInstance(null, propertyValues);
//		}
//
//		public virtual object CreateInstance(ITypeDescriptorContext context, IDictionary propertyValues)
//		{
//			return null;
//		}
//
//		public bool GetCreateInstanceSupported()
//		{
//			return GetCreateInstanceSupported(null);
//		}
//
//		public virtual bool GetCreateInstanceSupported(ITypeDescriptorContext context)
//		{
//			return false;
//		}
//
//		public PropertyDescriptorCollection GetProperties(object value)
//		{
//			return GetProperties(null, value);
//		}
//
//		public PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value)
//		{
//			return GetProperties(context, value, new Attribute[] { /*BrowsableAttribute.Yes*/ });
//		}
//
//		public virtual PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context,
//									   object value, Attribute[] attributes)
//		{
//			return null;
//		}
//
//		public bool GetPropertiesSupported()
//		{
//			return GetPropertiesSupported(null);
//		}
//
//		public virtual bool GetPropertiesSupported(ITypeDescriptorContext context)
//		{
//			return false;
//		}
//
//		public ICollection GetStandardValues()
//		{
//			return GetStandardValues(null);
//		}
//
//		public virtual StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
//		{
//			return null;
//		}
//
//		public bool GetStandardValuesExclusive()
//		{
//			return GetStandardValuesExclusive(null);
//		}
//
//		public virtual bool GetStandardValuesExclusive(ITypeDescriptorContext context)
//		{
//			return false;
//		}
//
//		public bool GetStandardValuesSupported()
//		{
//			return GetStandardValuesSupported(null);
//		}
//
//		public virtual bool GetStandardValuesSupported(ITypeDescriptorContext context)
//		{
//			return false;
//		}
//
//		public bool IsValid(object value)
//		{
//			return IsValid(null, value);
//		}
//
//		public virtual bool IsValid(ITypeDescriptorContext context, object value)
//		{
//			return true;
//		}
//
//		protected PropertyDescriptorCollection SortProperties(PropertyDescriptorCollection props, string[] names)
//		{
//			props.Sort(names);
//			return props;
//		}
//
//		public class StandardValuesCollection : ICollection, IEnumerable
//		{
//			private ICollection values;
//
//			public StandardValuesCollection(ICollection values)
//			{
//				this.values = values;
//			}
//
//			void ICollection.CopyTo(Array array, int index)
//			{
//				CopyTo(array, index);
//			}
//
//			public void CopyTo(Array array, int index)
//			{
//				values.CopyTo(array, index);
//			}
//
//			IEnumerator IEnumerable.GetEnumerator()
//			{
//				return GetEnumerator();
//			}
//
//			public IEnumerator GetEnumerator()
//			{
//				return values.GetEnumerator();
//			}
//
//			bool ICollection.IsSynchronized
//			{
//				get { return false; }
//			}
//
//			object ICollection.SyncRoot
//			{
//				get { return null; }
//			}
//
//			int ICollection.Count
//			{
//				get { return this.Count; }
//			}
//
//			public int Count
//			{
//				get { return values.Count; }
//			}
//
//			public object this[int index]
//			{
//				get { return ((IList)values)[index]; }
//			}
//		}
//
//		protected abstract class SimplePropertyDescriptor : PropertyDescriptorDummy
//		{
//			private Type componentType;
//			private Type propertyType;
//
//#if NET_4_0
//			protected
//#else
//			public
//#endif
// SimplePropertyDescriptor(Type componentType,
//							 string name,
//							 Type propertyType) :
//				this(componentType, name, propertyType, null)
//			{
//			}
//
//#if NET_4_0
//			protected
//#else
//			public
//#endif
// SimplePropertyDescriptor(Type componentType,
//							 string name,
//							 Type propertyType,
//							 Attribute[] attributes)
//				: base(/*name, attributes*/)
//			{
//				this.componentType = componentType;
//				this.propertyType = propertyType;
//			}
//
//			public Type ComponentType
//			{
//				get { return componentType; }
//			}
//
//			public Type PropertyType
//			{
//				get { return propertyType; }
//			}
//
//			public bool IsReadOnly
//			{
//				get
//				{
//					return false; /*Attributes.Contains(ReadOnlyAttribute.Yes);*/
//				}
//			}
//
//			public override bool ShouldSerializeValue(object component)
//			{
//				return false;
//			}
//
//			public override bool CanResetValue(object component)
//			{
//				DefaultValueAttribute Attrib = ((DefaultValueAttribute)Attributes[typeof(DefaultValueAttribute)]);
//				if (Attrib == null)
//				{
//					return false;
//				}
//				return (Attrib.Value == GetValue(component));
//			}
//
//			public override void ResetValue(object component)
//			{
//				DefaultValueAttribute Attrib = ((DefaultValueAttribute)Attributes[typeof(DefaultValueAttribute)]);
//				if (Attrib != null)
//				{
//					SetValue(component, Attrib.Value);
//				}
//
//			}
//		}
//	}
//}
//
//namespace System.ComponentModel.Design.Serialization
//{
//	public sealed class InstanceDescriptor
//	{
//
//		private MemberInfo member;
//		private ICollection arguments;
//		private bool isComplete;
//
//		public InstanceDescriptor(MemberInfo member, ICollection arguments)
//			: this(member, arguments, true)
//		{
//		}
//
//		public InstanceDescriptor(MemberInfo member, ICollection arguments, bool isComplete)
//		{
//			this.isComplete = isComplete;
//			ValidateMember(member, arguments);
//			this.member = member;
//			this.arguments = arguments;
//		}
//
//		private void ValidateMember(MemberInfo member, ICollection arguments)
//		{
//			if (member == null)
//				return;
//
//			switch (member.MemberType)
//			{
//				// According to docs only these types are allowed, but the docs do
//				// state what happens for other types
//				case MemberTypes.Constructor:
//					ConstructorInfo CI = (ConstructorInfo)member;
//					if (arguments == null) // null counts as no arguments
//						if (CI.GetParameters().Length != 0)
//							throw new ArgumentException("Invalid number of arguments for this constructor");
//					if (arguments.Count != CI.GetParameters().Length)
//						throw new ArgumentException("Invalid number of arguments for this constructor");
//					break;
//				case MemberTypes.Method:
//					MethodInfo MI = (MethodInfo)member;
//					if (!MI.IsStatic)
//						throw new ArgumentException("InstanceDescriptor only describes static (VB.Net: shared) members", "member");
//					if (arguments == null) // null counts as no arguments
//						if (MI.GetParameters().Length != 0)
//							throw new ArgumentException("Invalid number of arguments for this method", "arguments");
//					if (arguments.Count != MI.GetParameters().Length)
//						throw new ArgumentException("Invalid number of arguments for this method");
//					break;
//				case MemberTypes.Field:
//					FieldInfo FI = (FieldInfo)member;
//					if (!FI.IsStatic)
//						throw new ArgumentException("Parameter must be static");
//					if (arguments != null && arguments.Count != 0) // null counts as no arguments
//						throw new ArgumentException("Field members do not take any arguments");
//					break;
//				case MemberTypes.Property:
//					PropertyInfo PI = (PropertyInfo)member;
//					if (!(PI.CanRead))
//						throw new ArgumentException("Parameter must be readable");
//					MethodInfo PIM = PI.GetGetMethod();
//					if (!PIM.IsStatic)
//						throw new ArgumentException("Parameter must be static");
//					break;
//			}
//		}
//
//		public ICollection Arguments
//		{
//			get
//			{
//				// It seems MS does not return null even if we specified null as parameter (but does not cause an exception)
//				if (arguments == null)
//					return new object[0];
//				return arguments;
//			}
//		}
//
//		public bool IsComplete
//		{
//			get { return isComplete; }
//		}
//
//		public MemberInfo MemberInfo
//		{
//			get { return member; }
//		}
//
//		public object Invoke()
//		{
//			if (member == null)
//				return null;
//
//			object[] parsearguments;
//			if (arguments == null)
//				parsearguments = new object[0];
//			else
//			{
//				parsearguments = new object[arguments.Count];
//				arguments.CopyTo(parsearguments, 0);
//			}
//
//			//MemberInfo member;
//			switch (member.MemberType)
//			{
//				case MemberTypes.Constructor:
//					ConstructorInfo CI = (ConstructorInfo)member;
//					return CI.Invoke(parsearguments);
//
//				case MemberTypes.Method:
//					MethodInfo MI = (MethodInfo)member;
//					return MI.Invoke(null, parsearguments);
//
//				case MemberTypes.Field:
//					FieldInfo FI = (FieldInfo)member;
//					return FI.GetValue(null);
//
//				case MemberTypes.Property:
//					PropertyInfo PI = (PropertyInfo)member;
//					return PI.GetValue(null, parsearguments);
//			}
//			return null;
//		}
//	}
//
//	/// <summary>
//	/// Represents a collection of PropertyDescriptor objects.
//	/// </summary>
//	public class PropertyDescriptorCollection : IList, ICollection, IEnumerable, IDictionary
//	{
//		public static readonly PropertyDescriptorCollection Empty = new PropertyDescriptorCollection(null, true);
//		private List<object> properties;
//		private bool readOnly;
//
//		public PropertyDescriptorCollection(PropertyDescriptor[] properties)
//		{
//			this.properties = new List<object>();
//			if (properties == null)
//				return;
//
//			this.properties.AddRange(properties);
//		}
//
//#if NET_2_0
//		public
//#else
//		internal
//#endif
// PropertyDescriptorCollection(PropertyDescriptor[] properties, bool readOnly)
//			: this(properties)
//		{
//			this.readOnly = readOnly;
//		}
//
//		private PropertyDescriptorCollection()
//		{
//		}
//
//		public int Add(PropertyDescriptor value)
//		{
//			if (readOnly)
//			{
//				throw new NotSupportedException();
//			}
//			properties.Add(value);
//			return properties.Count - 1;
//		}
//
//		int IList.Add(object value)
//		{
//			return Add((PropertyDescriptor)value);
//		}
//
//		void IDictionary.Add(object key, object value)
//		{
//			if ((value as PropertyDescriptor) == null)
//			{
//				throw new ArgumentException("value");
//			}
//
//			Add((PropertyDescriptor)value);
//		}
//
//		public void Clear()
//		{
//			if (readOnly)
//			{
//				throw new NotSupportedException();
//			}
//			properties.Clear();
//		}
//
//#if !TARGET_JVM // DUAL_IFACE_CONFLICT
//		void IList.Clear()
//		{
//			Clear();
//		}
//
//		void IDictionary.Clear()
//		{
//			Clear();
//		}
//#endif
//
//		public bool Contains(PropertyDescriptor value)
//		{
//			return properties.Contains(value);
//		}
//
//#if TARGET_JVM // DUAL_IFACE_CONFLICT
//		public bool Contains (object value)
//		{
//			return Contains ((PropertyDescriptor) value);
//		}
//#else
//
//		bool IList.Contains(object value)
//		{
//			return Contains((PropertyDescriptor)value);
//		}
//
//		bool IDictionary.Contains(object value)
//		{
//			return Contains((PropertyDescriptor)value);
//		}
//#endif
//
//		public void CopyTo(Array array, int index)
//		{
//			properties.CopyTo(array, index);
//		}
//
//		public virtual PropertyDescriptor Find(string name, bool ignoreCase)
//		{
//			if (name == null)
//				throw new ArgumentNullException("name");
//
//			for (int i = 0; i < properties.Count; ++i)
//			{
//				PropertyDescriptor p = (PropertyDescriptor)properties[i];
//#if NET_2_0
//				if (ignoreCase) {
//					if (0 == String.Compare (name, p.Name, StringComparison.OrdinalIgnoreCase))
//						return p;
//				}
//				else {
//					if (0 == String.Compare (name, p.Name, StringComparison.Ordinal))
//						return p;
//				}
//#else
//				if (ignoreCase)
//				{
//					if (0 == String.CompareOrdinal(name.ToLower(System.Globalization.CultureInfo.InvariantCulture),
//						p.Name.ToLower(System.Globalization.CultureInfo.InvariantCulture)))
//						return p;
//				}
//				else
//				{
//					if (0 == String.CompareOrdinal(name, p.Name))
//						return p;
//				}
//#endif
//			}
//			return null;
//		}
//
//		public virtual IEnumerator GetEnumerator()
//		{
//			return properties.GetEnumerator();
//		}
//
//		IEnumerator IEnumerable.GetEnumerator()
//		{
//			return GetEnumerator();
//		}
//
//		IDictionaryEnumerator IDictionary.GetEnumerator()
//		{
//			throw new NotImplementedException();
//		}
//
//		public int IndexOf(PropertyDescriptor value)
//		{
//			return properties.IndexOf(value);
//		}
//
//		int IList.IndexOf(object value)
//		{
//			return IndexOf((PropertyDescriptor)value);
//		}
//
//		public void Insert(int index, PropertyDescriptor value)
//		{
//			if (readOnly)
//			{
//				throw new NotSupportedException();
//			}
//			properties.Insert(index, value);
//		}
//
//		void IList.Insert(int index, object value)
//		{
//			Insert(index, (PropertyDescriptor)value);
//		}
//
//		public void Remove(PropertyDescriptor value)
//		{
//			if (readOnly)
//			{
//				throw new NotSupportedException();
//			}
//			properties.Remove(value);
//		}
//
//#if TARGET_JVM// DUAL_IFACE_CONFLICT
//		public void Remove (object value)
//		{
//			Remove ((PropertyDescriptor) value);
//		}
//#else
//		void IDictionary.Remove(object value)
//		{
//			Remove((PropertyDescriptor)value);
//		}
//
//		void IList.Remove(object value)
//		{
//			Remove((PropertyDescriptor)value);
//		}
//#endif
//		public void RemoveAt(int index)
//		{
//			if (readOnly)
//			{
//				throw new NotSupportedException();
//			}
//			properties.RemoveAt(index);
//		}
//
//		void IList.RemoveAt(int index)
//		{
//			RemoveAt(index);
//		}
//
//		private PropertyDescriptorCollection CloneCollection()
//		{
//			PropertyDescriptorCollection col = new PropertyDescriptorCollection();
//			col.properties = new List<object>(properties);
//			return col;
//		}
//
//		public virtual PropertyDescriptorCollection Sort()
//		{
//			PropertyDescriptorCollection col = CloneCollection();
//			col.InternalSort((IComparer)null);
//			return col;
//		}
//
//		public virtual PropertyDescriptorCollection Sort(IComparer comparer)
//		{
//			PropertyDescriptorCollection col = CloneCollection();
//			col.InternalSort(comparer);
//			return col;
//		}
//
//		public virtual PropertyDescriptorCollection Sort(string[] order)
//		{
//			PropertyDescriptorCollection col = CloneCollection();
//			col.InternalSort(order);
//			return col;
//		}
//
//		public virtual PropertyDescriptorCollection Sort(string[] order, IComparer comparer)
//		{
//			PropertyDescriptorCollection col = CloneCollection();
//			if (order != null)
//			{
//				ArrayList sorted = col.ExtractItems(order);
//				col.InternalSort(comparer);
//				sorted.AddRange(col.properties);
//				col.properties = sorted;
//			}
//			else
//			{
//				col.InternalSort(comparer);
//			}
//			return col;
//		}
//
//		protected void InternalSort(IComparer ic)
//		{
//			if (ic == null)
//				ic = MemberDescriptor.DefaultComparer;
//			properties.Sort(ic);
//		}
//
//		protected void InternalSort(string[] order)
//		{
//			if (order != null)
//			{
//				ArrayList sorted = ExtractItems(order);
//				InternalSort((IComparer)null);
//				sorted.AddRange(properties);
//				properties = sorted;
//			}
//			else
//			{
//				InternalSort((IComparer)null);
//			}
//		}
//
//		ArrayList ExtractItems(string[] names)
//		{
//			ArrayList sorted = new ArrayList(properties.Count);
//			object[] ext = new object[names.Length];
//
//			for (int n = 0; n < properties.Count; n++)
//			{
//				PropertyDescriptor ed = (PropertyDescriptor)properties[n];
//				int i = Array.IndexOf(names, ed.Name);
//				if (i != -1)
//				{
//					ext[i] = ed;
//					properties.RemoveAt(n);
//					n--;
//				}
//			}
//			foreach (object ob in ext)
//				if (ob != null) sorted.Add(ob);
//
//			return sorted;
//		}
//
//		internal PropertyDescriptorCollection Filter(Attribute[] attributes)
//		{
//			ArrayList list = new ArrayList();
//			foreach (PropertyDescriptor pd in properties)
//			{
//				if (pd.Attributes.Contains(attributes))
//				{
//					list.Add(pd);
//				}
//			}
//			PropertyDescriptor[] descriptors = new PropertyDescriptor[list.Count];
//			list.CopyTo(descriptors);
//			return new PropertyDescriptorCollection(descriptors, true);
//		}
//
//#if TARGET_JVM //DUAL_IFACE_CONFLICT
//		public bool IsFixedSize
//#else
//		bool IDictionary.IsFixedSize
//		{
//			get { return ((IList)this).IsFixedSize; }
//		}
//		bool IList.IsFixedSize
//#endif
//		{
//			get
//			{
//#if NET_2_0
//				return readOnly;
//#else
//				return !readOnly;
//#endif
//			}
//		}
//#if TARGET_JVM //DUAL_IFACE_CONFLICT
//		public bool IsReadOnly
//#else
//		bool IDictionary.IsReadOnly
//		{
//			get { return ((IList)this).IsReadOnly; }
//		}
//		bool IList.IsReadOnly
//#endif
//		{
//			get
//			{
//				return readOnly;
//			}
//		}
//
//		bool ICollection.IsSynchronized
//		{
//			get
//			{
//				return false;
//			}
//		}
//
//		int ICollection.Count
//		{
//			get { return Count; }
//		}
//
//		public int Count
//		{
//			get
//			{
//				return properties.Count;
//			}
//		}
//
//		object ICollection.SyncRoot
//		{
//			get
//			{
//				return null;
//			}
//		}
//
//		ICollection IDictionary.Keys
//		{
//			get
//			{
//				string[] keys = new string[properties.Count];
//				int i = 0;
//				foreach (PropertyDescriptor p in properties)
//					keys[i++] = p.Name;
//				return keys;
//			}
//		}
//
//		ICollection IDictionary.Values
//		{
//			get
//			{
//				return (ICollection)properties.Clone();
//			}
//		}
//
//		object IDictionary.this[object key]
//		{
//			get
//			{
//				if (!(key is string))
//					return null;
//				return this[(string)key];
//			}
//			set
//			{
//				if (readOnly)
//				{
//					throw new NotSupportedException();
//				}
//
//				if (!(key is string) || (value as PropertyDescriptor) == null)
//					throw new ArgumentException();
//				int idx = properties.IndexOf(value);
//				if (idx == -1)
//					Add((PropertyDescriptor)value);
//				else
//					properties[idx] = value;
//			}
//		}
//
//		public virtual PropertyDescriptor this[string s]
//		{
//			get
//			{
//				return Find(s, false);
//			}
//		}
//
//		object IList.this[int index]
//		{
//			get
//			{
//				return properties[index];
//			}
//			set
//			{
//				if (readOnly)
//				{
//					throw new NotSupportedException();
//				}
//				properties[index] = value;
//			}
//		}
//
//		public virtual PropertyDescriptor this[int index]
//		{
//			get
//			{
//				return (PropertyDescriptor)properties[index];
//			}
//		}
//	}
//
//
//}
//
//
//namespace System.Reflection
//{
//
//
//	/// <summary>
//	/// </summary>
//	[ComVisible(true)]
//	[Serializable]
//	[Flags]
//	public enum MemberTypes
//	{
//
//		/// <summary>
//		/// </summary>
//		Constructor = 1,
//
//		/// <summary>
//		/// </summary>
//		Event = 2,
//
//		/// <summary>
//		/// </summary>
//		Field = 4,
//
//		/// <summary>
//		/// </summary>
//		Method = 8,
//
//		/// <summary>
//		/// </summary>
//		Property = 16,
//
//		/// <summary>
//		/// </summary>
//		TypeInfo = 32,
//
//		/// <summary>
//		/// </summary>
//		Custom = 64,
//
//		/// <summary>
//		/// </summary>
//		NestedType = 128,
//
//		/// <summary>
//		/// </summary>
//		All = 191,
//	} // MemberTypes
//
//}
#endif